#ifndef _THREAD_H_
#define _THREAD_H_

#include <iostream>
#include <string>
#include <pthread.h>
#include <cstdio>
#include <cstring>
#include <functional>
#include <atomic>
#include <memory>  // 可选，用于智能指针管理资源

namespace ThreadModule {  
    inline std::atomic<uint32_t> thread_num(1);  // 自定义线程编号（区分系统tid）

    static uint32_t GetThreadNum() {  
        return thread_num++;
    }

    // 模板参数：函数类型F和参数包Args
    template <class F, class... Args>
    class Thread {
    private:
        using func_t = std::function<void()>;  // 绑定后为无参函数

        // 需要static -- 符合pthread的C标准形式，否则会有隐藏的 this* 干扰
        static void* Routine(void* args) {
            Thread* self = static_cast<Thread*>(args); // 静态成员函数可以间接访问成员函数的原因
            // 执行用户任务
            self->_func();
            self->_isrunning = false;  // 任务结束后标记为未运行
            return nullptr;
        }

    public:
        // 构造函数：绑定函数和参数
        Thread(F&& func, Args&&... args)
            : _tid(0),
              _isdetach(false),
              _isrunning(false),
              _res(nullptr),
              _func(std::bind(std::forward<F>(func), std::forward<Args>(args)...)) {
            _name = "线程[" + std::to_string(GetThreadNum()) + "]";
        }

        // 启动线程
        bool Start() {
            if (_isrunning) return false;  // 已运行则返回失败
            int n = pthread_create(&_tid, nullptr, Routine, this);
            if (n != 0) {
                std::cerr << "创建线程失败: " << strerror(n) << std::endl;
                return false;
            }
            _isrunning = true;  // 成功创建后标记为运行中
            std::cout << _name << " 创建成功 (tid: " << _tid << ")" << std::endl;
            return true;
        }

        // 优雅终止（建议用此方式替代pthread_cancel）
        void SetStopFlag() {
            _stop_flag = true;  // 需要用户在任务函数中检查此标志
        }

        // 新增：获取停止标志（供用户任务检查，避免直接访问私有成员）
        bool GetStopFlag() const {
            return _stop_flag;
        }

        // 等待线程结束
        void Join() {
            if (_isdetach) {
                std::cerr << _name << " 已分离，无法执行join" << std::endl;
                return;
            }
            if (!_isrunning) {
                std::cerr << _name << " 未在运行中" << std::endl;
                return;
            }
            int n = pthread_join(_tid, &_res);
            if (n != 0) {
                std::cerr << "join失败: " << strerror(n) << std::endl;
            } else {
                _isrunning = false;
                std::cout << _name << " 已join" << std::endl;
            }
        }

        // 分离线程
        void Detach() {
            if (_isdetach) return;
            if (!_isrunning) {
                std::cerr << _name << " 未在运行中，无法分离" << std::endl;
                return;
            }
            pthread_detach(_tid);
            _isdetach = true;
            std::cout << _name << " 已分离" << std::endl;
        }

        // 析构函数：不主动join，避免阻塞，由用户管理
        ~Thread() {
            if (_isrunning && !_isdetach) {
                std::cerr << "警告: 线程 " << _name << " 未执行join/分离操作" << std::endl;
                // 此处不建议调用pthread_join，可能导致析构阻塞
            }
        }

        // 获取线程状态（示例接口）
        bool IsRunning() const { return _isrunning; }
        pthread_t GetTid() const { return _tid; }
        const std::string& GetName() const { return _name; }

    private:
        pthread_t _tid;                  // 系统线程ID
        std::string _name;               // 线程名称（含自定义编号）
        std::atomic<bool> _isdetach{false};  // 是否分离
        std::atomic<bool> _isrunning{false}; // 是否运行中
        std::atomic<bool> _stop_flag{false}; // 优雅终止标志（供用户任务检查）
        void* _res;                      // 线程返回值（通常无用）
        func_t _func;                    // 任务函数
    };
}

#endif